
alignment-doublelist:     file format elf32-littlearm


Disassembly of section .init:

000103a8 <_init>:
   103a8:	e1a0c00d 	mov	ip, sp
   103ac:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   103b0:	e24cb004 	sub	fp, ip, #4
   103b4:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}

Disassembly of section .plt:

000103b8 <printf@plt-0x14>:
   103b8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
   103bc:	e59fe004 	ldr	lr, [pc, #4]	; 103c8 <_init+0x20>
   103c0:	e08fe00e 	add	lr, pc, lr
   103c4:	e5bef008 	ldr	pc, [lr, #8]!
   103c8:	000107f0 	.word	0x000107f0

000103cc <printf@plt>:
   103cc:	e28fc600 	add	ip, pc, #0, 12
   103d0:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103d4:	e5bcf7f0 	ldr	pc, [ip, #2032]!	; 0x7f0

000103d8 <puts@plt>:
   103d8:	e28fc600 	add	ip, pc, #0, 12
   103dc:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103e0:	e5bcf7e8 	ldr	pc, [ip, #2024]!	; 0x7e8

000103e4 <malloc@plt>:
   103e4:	e28fc600 	add	ip, pc, #0, 12
   103e8:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103ec:	e5bcf7e0 	ldr	pc, [ip, #2016]!	; 0x7e0

000103f0 <abort@plt>:
   103f0:	e28fc600 	add	ip, pc, #0, 12
   103f4:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103f8:	e5bcf7d8 	ldr	pc, [ip, #2008]!	; 0x7d8

000103fc <__deregister_frame_info@plt>:
   103fc:	e28fc600 	add	ip, pc, #0, 12
   10400:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10404:	e5bcf7d0 	ldr	pc, [ip, #2000]!	; 0x7d0

00010408 <__uClibc_main@plt>:
   10408:	e28fc600 	add	ip, pc, #0, 12
   1040c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10410:	e5bcf7c8 	ldr	pc, [ip, #1992]!	; 0x7c8

00010414 <exit@plt>:
   10414:	e28fc600 	add	ip, pc, #0, 12
   10418:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1041c:	e5bcf7c0 	ldr	pc, [ip, #1984]!	; 0x7c0

00010420 <__register_frame_info@plt>:
   10420:	e28fc600 	add	ip, pc, #0, 12
   10424:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10428:	e5bcf7b8 	ldr	pc, [ip, #1976]!	; 0x7b8

0001042c <free@plt>:
   1042c:	e28fc600 	add	ip, pc, #0, 12
   10430:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10434:	e5bcf7b0 	ldr	pc, [ip, #1968]!	; 0x7b0

Disassembly of section .text:

00010438 <_start>:
   10438:	e3a0b000 	.word	0xe3a0b000
   1043c:	e3a0e000 	.word	0xe3a0e000
   10440:	e49d1004 	.word	0xe49d1004
   10444:	e1a0200d 	.word	0xe1a0200d
   10448:	e52d2004 	.word	0xe52d2004
   1044c:	e52d0004 	.word	0xe52d0004
   10450:	e59fc010 	.word	0xe59fc010
   10454:	e52dc004 	.word	0xe52dc004
   10458:	e59f000c 	.word	0xe59f000c
   1045c:	e59f300c 	.word	0xe59f300c
   10460:	eaffffe8 	.word	0xeaffffe8
   10464:	ebffffe1 	.word	0xebffffe1
   10468:	00010a7c 	.word	0x00010a7c
   1046c:	00010930 	.word	0x00010930
   10470:	000103a8 	.word	0x000103a8

00010474 <deregister_tm_clones>:
   10474:	e59f301c 	ldr	r3, [pc, #28]	; 10498 <deregister_tm_clones+0x24>
   10478:	e59f001c 	ldr	r0, [pc, #28]	; 1049c <deregister_tm_clones+0x28>
   1047c:	e0603003 	rsb	r3, r0, r3
   10480:	e3530006 	cmp	r3, #6
   10484:	912fff1e 	bxls	lr
   10488:	e59f3010 	ldr	r3, [pc, #16]	; 104a0 <deregister_tm_clones+0x2c>
   1048c:	e3530000 	cmp	r3, #0
   10490:	012fff1e 	bxeq	lr
   10494:	e12fff13 	bx	r3
   10498:	00020bf3 	.word	0x00020bf3
   1049c:	00020bf0 	.word	0x00020bf0
   104a0:	00000000 	.word	0x00000000

000104a4 <register_tm_clones>:
   104a4:	e59f1024 	ldr	r1, [pc, #36]	; 104d0 <register_tm_clones+0x2c>
   104a8:	e59f0024 	ldr	r0, [pc, #36]	; 104d4 <register_tm_clones+0x30>
   104ac:	e0601001 	rsb	r1, r0, r1
   104b0:	e1a01141 	asr	r1, r1, #2
   104b4:	e0811fa1 	add	r1, r1, r1, lsr #31
   104b8:	e1b010c1 	asrs	r1, r1, #1
   104bc:	012fff1e 	bxeq	lr
   104c0:	e59f3010 	ldr	r3, [pc, #16]	; 104d8 <register_tm_clones+0x34>
   104c4:	e3530000 	cmp	r3, #0
   104c8:	012fff1e 	bxeq	lr
   104cc:	e12fff13 	bx	r3
   104d0:	00020bf0 	.word	0x00020bf0
   104d4:	00020bf0 	.word	0x00020bf0
   104d8:	00000000 	.word	0x00000000

000104dc <__do_global_dtors_aux>:
   104dc:	e92d4010 	push	{r4, lr}
   104e0:	e59f402c 	ldr	r4, [pc, #44]	; 10514 <__do_global_dtors_aux+0x38>
   104e4:	e5d43000 	ldrb	r3, [r4]
   104e8:	e3530000 	cmp	r3, #0
   104ec:	18bd8010 	popne	{r4, pc}
   104f0:	ebffffdf 	bl	10474 <deregister_tm_clones>
   104f4:	e59f301c 	ldr	r3, [pc, #28]	; 10518 <__do_global_dtors_aux+0x3c>
   104f8:	e3530000 	cmp	r3, #0
   104fc:	0a000001 	beq	10508 <__do_global_dtors_aux+0x2c>
   10500:	e59f0014 	ldr	r0, [pc, #20]	; 1051c <__do_global_dtors_aux+0x40>
   10504:	ebffffbc 	bl	103fc <__deregister_frame_info@plt>
   10508:	e3a03001 	mov	r3, #1
   1050c:	e5c43000 	strb	r3, [r4]
   10510:	e8bd8010 	pop	{r4, pc}
   10514:	00020bf0 	.word	0x00020bf0
   10518:	00000000 	.word	0x00000000
   1051c:	00010af0 	.word	0x00010af0

00010520 <frame_dummy>:
   10520:	e59f3040 	ldr	r3, [pc, #64]	; 10568 <frame_dummy+0x48>
   10524:	e92d4010 	push	{r4, lr}
   10528:	e3530000 	cmp	r3, #0
   1052c:	0a000002 	beq	1053c <frame_dummy+0x1c>
   10530:	e59f1034 	ldr	r1, [pc, #52]	; 1056c <frame_dummy+0x4c>
   10534:	e59f0034 	ldr	r0, [pc, #52]	; 10570 <frame_dummy+0x50>
   10538:	ebffffb8 	bl	10420 <__register_frame_info@plt>
   1053c:	e59f0030 	ldr	r0, [pc, #48]	; 10574 <frame_dummy+0x54>
   10540:	e5903000 	ldr	r3, [r0]
   10544:	e3530000 	cmp	r3, #0
   10548:	1a000001 	bne	10554 <frame_dummy+0x34>
   1054c:	e8bd4010 	pop	{r4, lr}
   10550:	eaffffd3 	b	104a4 <register_tm_clones>
   10554:	e59f301c 	ldr	r3, [pc, #28]	; 10578 <frame_dummy+0x58>
   10558:	e3530000 	cmp	r3, #0
   1055c:	0afffffa 	beq	1054c <frame_dummy+0x2c>
   10560:	e12fff33 	blx	r3
   10564:	eafffff8 	b	1054c <frame_dummy+0x2c>
   10568:	00000000 	.word	0x00000000
   1056c:	00020bf4 	.word	0x00020bf4
   10570:	00010af0 	.word	0x00010af0
   10574:	00020afc 	.word	0x00020afc
   10578:	00000000 	.word	0x00000000

0001057c <add>:
};

struct list * head;

void add(struct list * node)
{
   1057c:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   10580:	e28db000 	add	fp, sp, #0
   10584:	e24dd014 	sub	sp, sp, #20
   10588:	e50b0010 	str	r0, [fp, #-16] ; node
  struct list * src, * prev;

  if (head == NULL)
   1058c:	e59f312c 	ldr	r3, [pc, #300]	; 106c0 <add+0x144>
   10590:	e5933000 	ldr	r3, [r3]
   10594:	e3530000 	cmp	r3, #0
   10598:	1a000000 	bne	105a0 <add+0x24>
    return;
   1059c:	ea000044 	b	106b4 <add+0x138>

  src = head;  // 头结点,全局变量.当前结点.
   105a0:	e59f3118 	ldr	r3, [pc, #280]	; 106c0 <add+0x144>
   105a4:	e5933000 	ldr	r3, [r3]
   105a8:	e50b3008 	str	r3, [fp, #-8] ; src
  prev = src;  // 前结点.
   105ac:	e51b3008 	ldr	r3, [fp, #-8]
   105b0:	e50b300c 	str	r3, [fp, #-12]

  while (src->next != NULL) {
   105b4:	ea00002a 	b	10664 <add+0xe8>
    if (src->value <= node->value) { // 后移
   105b8:	e51b3008 	ldr	r3, [fp, #-8]
   105bc:	e5932008 	ldr	r2, [r3, #8]
   105c0:	e51b3010 	ldr	r3, [fp, #-16]
   105c4:	e5933008 	ldr	r3, [r3, #8]
   105c8:	e1520003 	cmp	r2, r3
   105cc:	ca000005 	bgt	105e8 <add+0x6c>
      prev = src;	  // 前结点.
   105d0:	e51b3008 	ldr	r3, [fp, #-8]
   105d4:	e50b300c 	str	r3, [fp, #-12]
      src = src->next;    // 下结点.
   105d8:	e51b3008 	ldr	r3, [fp, #-8]
   105dc:	e5933004 	ldr	r3, [r3, #4]
   105e0:	e50b3008 	str	r3, [fp, #-8]
   105e4:	ea00000c 	b	1061c <add+0xa0>
    }
    else {
      prev->next = node;  // 前结点指向新点.
   105e8:	e51b300c 	ldr	r3, [fp, #-12]
   105ec:	e51b2010 	ldr	r2, [fp, #-16]
   105f0:	e5832004 	str	r2, [r3, #4]
      node->prev = prev;  // 新结点前驱指向前结点.
   105f4:	e51b3010 	ldr	r3, [fp, #-16]
   105f8:	e51b200c 	ldr	r2, [fp, #-12]
   105fc:	e5832000 	str	r2, [r3]
      node->next = src;   // 新结点后驱指向下结点.
   10600:	e51b3010 	ldr	r3, [fp, #-16]
   10604:	e51b2008 	ldr	r2, [fp, #-8]
   10608:	e5832004 	str	r2, [r3, #4]
      src->prev = node;   // 下结点前驱指向新结点.即插入.
   1060c:	e51b3008 	ldr	r3, [fp, #-8]
   10610:	e51b2010 	ldr	r2, [fp, #-16]
   10614:	e5832000 	str	r2, [r3]
      break;
   10618:	ea000015 	b	10674 <add+0xf8>
    }

    if (src == head) {    // 从头结点开始.
   1061c:	e59f309c 	ldr	r3, [pc, #156]	; 106c0 <add+0x144>
   10620:	e5933000 	ldr	r3, [r3]
   10624:	e51b2008 	ldr	r2, [fp, #-8]
   10628:	e1520003 	cmp	r2, r3
   1062c:	1a00000c 	bne	10664 <add+0xe8>
      prev->next = node;  // 前结点指向新点. 
   10630:	e51b300c 	ldr	r3, [fp, #-12]
   10634:	e51b2010 	ldr	r2, [fp, #-16]
   10638:	e5832004 	str	r2, [r3, #4]
      node->prev = prev;  // 新结点前驱指向前结点.
   1063c:	e51b3010 	ldr	r3, [fp, #-16]
   10640:	e51b200c 	ldr	r2, [fp, #-12]
   10644:	e5832000 	str	r2, [r3]
      node->next = src;   // 新结点后驱指向下结点
   10648:	e51b3010 	ldr	r3, [fp, #-16]
   1064c:	e51b2008 	ldr	r2, [fp, #-8]
   10650:	e5832004 	str	r2, [r3, #4]
      src->prev = node;   // 下结点前驱指向新结点.即插入.
   10654:	e51b3008 	ldr	r3, [fp, #-8]
   10658:	e51b2010 	ldr	r2, [fp, #-16]
   1065c:	e5832000 	str	r2, [r3]
      break;
   10660:	ea000003 	b	10674 <add+0xf8>
    return;

  src = head;  // 头结点,全局变量.当前结点.
  prev = src;  // 前结点.

  while (src->next != NULL) {
   10664:	e51b3008 	ldr	r3, [fp, #-8]
   10668:	e5933004 	ldr	r3, [r3, #4]
   1066c:	e3530000 	cmp	r3, #0
   10670:	1affffd0 	bne	105b8 <add+0x3c>
      src->prev = node;   // 下结点前驱指向新结点.即插入.
      break;
    }
  }

  if (src->next == NULL) { // 从空结点开始.
   10674:	e51b3008 	ldr	r3, [fp, #-8]
   10678:	e5933004 	ldr	r3, [r3, #4]
   1067c:	e3530000 	cmp	r3, #0
   10680:	1a00000b 	bne	106b4 <add+0x138>
    prev->next = node;     // 指向新结点
   10684:	e51b300c 	ldr	r3, [fp, #-12]
   10688:	e51b2010 	ldr	r2, [fp, #-16]
   1068c:	e5832004 	str	r2, [r3, #4]
    node->next = src;      // 新结点指向当前结点.
   10690:	e51b3010 	ldr	r3, [fp, #-16]
   10694:	e51b2008 	ldr	r2, [fp, #-8]
   10698:	e5832004 	str	r2, [r3, #4]
    node->prev = prev;     // 新结点前驱指向前结点.
   1069c:	e51b3010 	ldr	r3, [fp, #-16]
   106a0:	e51b200c 	ldr	r2, [fp, #-12]
   106a4:	e5832000 	str	r2, [r3]
    src->prev = node;      // 当前结点前驱指向新结点.
   106a8:	e51b3008 	ldr	r3, [fp, #-8]
   106ac:	e51b2010 	ldr	r2, [fp, #-16]
   106b0:	e5832000 	str	r2, [r3]
  }
}
   106b4:	e24bd000 	sub	sp, fp, #0
   106b8:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   106bc:	e12fff1e 	bx	lr
   106c0:	00020c0c 	.word	0x00020c0c

000106c4 <del>:

void del(int value)
{
   106c4:	e92d4800 	push	{fp, lr}
   106c8:	e28db004 	add	fp, sp, #4
   106cc:	e24dd018 	sub	sp, sp, #24
   106d0:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
  struct list * src, * prev, * temp;

  src = head->next;  // 头结点的下结点.
   106d4:	e59f30c4 	ldr	r3, [pc, #196]	; 107a0 <del+0xdc>
   106d8:	e5933000 	ldr	r3, [r3]
   106dc:	e5933004 	ldr	r3, [r3, #4]
   106e0:	e50b3008 	str	r3, [fp, #-8]
  prev = src;        // 用作前结点
   106e4:	e51b3008 	ldr	r3, [fp, #-8]
   106e8:	e50b300c 	str	r3, [fp, #-12]

  while (src->next != head->next) { // prt->next 为 head->next->next, 即head->next的下一个结点.
   106ec:	ea000022 	b	1077c <del+0xb8>
    if (src->value == value) {
   106f0:	e51b3008 	ldr	r3, [fp, #-8]
   106f4:	e5932008 	ldr	r2, [r3, #8]
   106f8:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   106fc:	e1520003 	cmp	r2, r3
   10700:	1a00000f 	bne	10744 <del+0x80>
      temp = src;              // 要删除的结点.
   10704:	e51b3008 	ldr	r3, [fp, #-8]
   10708:	e50b3010 	str	r3, [fp, #-16]
      prev->next = src->next;  // ptr->next = 要删除的结点指针指向下结点.
   1070c:	e51b3008 	ldr	r3, [fp, #-8]
   10710:	e5932004 	ldr	r2, [r3, #4]
   10714:	e51b300c 	ldr	r3, [fp, #-12]
   10718:	e5832004 	str	r2, [r3, #4]
      src->next->prev = prev;
   1071c:	e51b3008 	ldr	r3, [fp, #-8]
   10720:	e5933004 	ldr	r3, [r3, #4]
   10724:	e51b200c 	ldr	r2, [fp, #-12]
   10728:	e5832000 	str	r2, [r3]
      free(temp);
   1072c:	e51b0010 	ldr	r0, [fp, #-16]
   10730:	ebffff3d 	bl	1042c <free@plt>
      printf("delete node of value is : %d\n", value);
   10734:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10738:	e59f0064 	ldr	r0, [pc, #100]	; 107a4 <del+0xe0>
   1073c:	ebffff22 	bl	103cc <printf@plt>
      break;
   10740:	ea000014 	b	10798 <del+0xd4>
    }
    else if (src->value < value) {
   10744:	e51b3008 	ldr	r3, [fp, #-8]
   10748:	e5932008 	ldr	r2, [r3, #8]
   1074c:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10750:	e1520003 	cmp	r2, r3
   10754:	aa000005 	bge	10770 <del+0xac>
      prev = src;
   10758:	e51b3008 	ldr	r3, [fp, #-8]
   1075c:	e50b300c 	str	r3, [fp, #-12]
      src = src->next;
   10760:	e51b3008 	ldr	r3, [fp, #-8]
   10764:	e5933004 	ldr	r3, [r3, #4]
   10768:	e50b3008 	str	r3, [fp, #-8]
   1076c:	ea000002 	b	1077c <del+0xb8>
    }
    else {
      printf("node\n");
   10770:	e59f0030 	ldr	r0, [pc, #48]	; 107a8 <del+0xe4>
   10774:	ebffff17 	bl	103d8 <puts@plt>
      break;
   10778:	ea000006 	b	10798 <del+0xd4>
  struct list * src, * prev, * temp;

  src = head->next;  // 头结点的下结点.
  prev = src;        // 用作前结点

  while (src->next != head->next) { // prt->next 为 head->next->next, 即head->next的下一个结点.
   1077c:	e51b3008 	ldr	r3, [fp, #-8]
   10780:	e5932004 	ldr	r2, [r3, #4]
   10784:	e59f3014 	ldr	r3, [pc, #20]	; 107a0 <del+0xdc>
   10788:	e5933000 	ldr	r3, [r3]
   1078c:	e5933004 	ldr	r3, [r3, #4]
   10790:	e1520003 	cmp	r2, r3
   10794:	1affffd5 	bne	106f0 <del+0x2c>
    else {
      printf("node\n");
      break;
    }
  }
}
   10798:	e24bd004 	sub	sp, fp, #4
   1079c:	e8bd8800 	pop	{fp, pc}
   107a0:	00020c0c 	.word	0x00020c0c
   107a4:	00010a8c 	.word	0x00010a8c
   107a8:	00010aac 	.word	0x00010aac

000107ac <new>:

struct list * new()
{
   107ac:	e92d4800 	push	{fp, lr}
   107b0:	e28db004 	add	fp, sp, #4
   107b4:	e24dd008 	sub	sp, sp, #8
  struct list * des;

  des = (struct list *) malloc (sizeof(struct list));
   107b8:	e3a00010 	mov	r0, #16
   107bc:	ebffff08 	bl	103e4 <malloc@plt>
   107c0:	e1a03000 	mov	r3, r0
   107c4:	e50b3008 	str	r3, [fp, #-8]
  if (!des) {
   107c8:	e51b3008 	ldr	r3, [fp, #-8]
   107cc:	e3530000 	cmp	r3, #0
   107d0:	1a000003 	bne	107e4 <new+0x38>
    printf("allocate failure.\n");
   107d4:	e59f0048 	ldr	r0, [pc, #72]	; 10824 <new+0x78>
   107d8:	ebfffefe 	bl	103d8 <puts@plt>
    return NULL;
   107dc:	e3a03000 	mov	r3, #0
   107e0:	ea00000c 	b	10818 <new+0x6c>
  }
  else {
    des->value = -1;
   107e4:	e51b3008 	ldr	r3, [fp, #-8]
   107e8:	e3e02000 	mvn	r2, #0
   107ec:	e5832008 	str	r2, [r3, #8]
    des->index = -1;
   107f0:	e51b3008 	ldr	r3, [fp, #-8]
   107f4:	e3e02000 	mvn	r2, #0
   107f8:	e583200c 	str	r2, [r3, #12]
    des->prev = NULL;
   107fc:	e51b3008 	ldr	r3, [fp, #-8]
   10800:	e3a02000 	mov	r2, #0
   10804:	e5832000 	str	r2, [r3]
    des->next = NULL;
   10808:	e51b3008 	ldr	r3, [fp, #-8]
   1080c:	e3a02000 	mov	r2, #0
   10810:	e5832004 	str	r2, [r3, #4]

    return des;
   10814:	e51b3008 	ldr	r3, [fp, #-8]
  }
}
   10818:	e1a00003 	mov	r0, r3
   1081c:	e24bd004 	sub	sp, fp, #4
   10820:	e8bd8800 	pop	{fp, pc}
   10824:	00010ab4 	.word	0x00010ab4

00010828 <display>:

void display(int order)
{
   10828:	e92d4800 	push	{fp, lr}
   1082c:	e28db004 	add	fp, sp, #4
   10830:	e24dd010 	sub	sp, sp, #16
   10834:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;
  int i = 1;
   10838:	e3a03001 	mov	r3, #1
   1083c:	e50b300c 	str	r3, [fp, #-12]

  if (!order) {
   10840:	e51b3010 	ldr	r3, [fp, #-16]
   10844:	e3530000 	cmp	r3, #0
   10848:	1a000019 	bne	108b4 <display+0x8c>
    src = head->next;
   1084c:	e59f30cc 	ldr	r3, [pc, #204]	; 10920 <display+0xf8>
   10850:	e5933000 	ldr	r3, [r3]
   10854:	e5933004 	ldr	r3, [r3, #4]
   10858:	e50b3008 	str	r3, [fp, #-8]
    printf("up order:\n");
   1085c:	e59f00c0 	ldr	r0, [pc, #192]	; 10924 <display+0xfc>
   10860:	ebfffedc 	bl	103d8 <puts@plt>
    while (src->next != head->next) {
   10864:	ea00000a 	b	10894 <display+0x6c>
      printf("i = %d : %d\n", i++, src->value);
   10868:	e51b300c 	ldr	r3, [fp, #-12]
   1086c:	e2832001 	add	r2, r3, #1
   10870:	e50b200c 	str	r2, [fp, #-12]
   10874:	e51b2008 	ldr	r2, [fp, #-8]
   10878:	e5922008 	ldr	r2, [r2, #8]
   1087c:	e1a01003 	mov	r1, r3
   10880:	e59f00a0 	ldr	r0, [pc, #160]	; 10928 <display+0x100>
   10884:	ebfffed0 	bl	103cc <printf@plt>
      src = src->next;
   10888:	e51b3008 	ldr	r3, [fp, #-8]
   1088c:	e5933004 	ldr	r3, [r3, #4]
   10890:	e50b3008 	str	r3, [fp, #-8]
  int i = 1;

  if (!order) {
    src = head->next;
    printf("up order:\n");
    while (src->next != head->next) {
   10894:	e51b3008 	ldr	r3, [fp, #-8]
   10898:	e5932004 	ldr	r2, [r3, #4]
   1089c:	e59f307c 	ldr	r3, [pc, #124]	; 10920 <display+0xf8>
   108a0:	e5933000 	ldr	r3, [r3]
   108a4:	e5933004 	ldr	r3, [r3, #4]
   108a8:	e1520003 	cmp	r2, r3
   108ac:	1affffed 	bne	10868 <display+0x40>
   108b0:	ea000018 	b	10918 <display+0xf0>
      printf("i = %d : %d\n", i++, src->value);
      src = src->next;
    }
  }
  else {
    src = head->prev;
   108b4:	e59f3064 	ldr	r3, [pc, #100]	; 10920 <display+0xf8>
   108b8:	e5933000 	ldr	r3, [r3]
   108bc:	e5933000 	ldr	r3, [r3]
   108c0:	e50b3008 	str	r3, [fp, #-8]
    printf("down order:\n");
   108c4:	e59f0060 	ldr	r0, [pc, #96]	; 1092c <display+0x104>
   108c8:	ebfffec2 	bl	103d8 <puts@plt>
    while (src->prev != head->prev) {
   108cc:	ea00000a 	b	108fc <display+0xd4>
      printf("i = %d : %d\n", i++, src->value);
   108d0:	e51b300c 	ldr	r3, [fp, #-12]
   108d4:	e2832001 	add	r2, r3, #1
   108d8:	e50b200c 	str	r2, [fp, #-12]
   108dc:	e51b2008 	ldr	r2, [fp, #-8]
   108e0:	e5922008 	ldr	r2, [r2, #8]
   108e4:	e1a01003 	mov	r1, r3
   108e8:	e59f0038 	ldr	r0, [pc, #56]	; 10928 <display+0x100>
   108ec:	ebfffeb6 	bl	103cc <printf@plt>
      src = src->prev;
   108f0:	e51b3008 	ldr	r3, [fp, #-8]
   108f4:	e5933000 	ldr	r3, [r3]
   108f8:	e50b3008 	str	r3, [fp, #-8]
    }
  }
  else {
    src = head->prev;
    printf("down order:\n");
    while (src->prev != head->prev) {
   108fc:	e51b3008 	ldr	r3, [fp, #-8]
   10900:	e5932000 	ldr	r2, [r3]
   10904:	e59f3014 	ldr	r3, [pc, #20]	; 10920 <display+0xf8>
   10908:	e5933000 	ldr	r3, [r3]
   1090c:	e5933000 	ldr	r3, [r3]
   10910:	e1520003 	cmp	r2, r3
   10914:	1affffed 	bne	108d0 <display+0xa8>
      printf("i = %d : %d\n", i++, src->value);
      src = src->prev;
    }
  }
}
   10918:	e24bd004 	sub	sp, fp, #4
   1091c:	e8bd8800 	pop	{fp, pc}
   10920:	00020c0c 	.word	0x00020c0c
   10924:	00010ac8 	.word	0x00010ac8
   10928:	00010ad4 	.word	0x00010ad4
   1092c:	00010ae4 	.word	0x00010ae4

00010930 <main>:

int main()
{
   10930:	e92d4800 	push	{fp, lr}
   10934:	e28db004 	add	fp, sp, #4
   10938:	e24dd008 	sub	sp, sp, #8
  struct list * des;
  int i;

  head = new();
   1093c:	ebffff9a 	bl	107ac <new>
   10940:	e1a02000 	mov	r2, r0
   10944:	e59f312c 	ldr	r3, [pc, #300]	; 10a78 <main+0x148>
   10948:	e5832000 	str	r2, [r3]
  if (head == NULL)
   1094c:	e59f3124 	ldr	r3, [pc, #292]	; 10a78 <main+0x148>
   10950:	e5933000 	ldr	r3, [r3]
   10954:	e3530000 	cmp	r3, #0
   10958:	1a000001 	bne	10964 <main+0x34>
    exit(-1);
   1095c:	e3e00000 	mvn	r0, #0
   10960:	ebfffeab 	bl	10414 <exit@plt>

  for (i = 0; i < 10; i++) {
   10964:	e3a03000 	mov	r3, #0
   10968:	e50b3008 	str	r3, [fp, #-8]
   1096c:	ea00000d 	b	109a8 <main+0x78>
    des = new();
   10970:	ebffff8d 	bl	107ac <new>
   10974:	e50b000c 	str	r0, [fp, #-12]
    des->value = i;
   10978:	e51b300c 	ldr	r3, [fp, #-12]
   1097c:	e51b2008 	ldr	r2, [fp, #-8]
   10980:	e5832008 	str	r2, [r3, #8]
    des->index = i + 1;
   10984:	e51b3008 	ldr	r3, [fp, #-8]
   10988:	e2832001 	add	r2, r3, #1
   1098c:	e51b300c 	ldr	r3, [fp, #-12]
   10990:	e583200c 	str	r2, [r3, #12]
    add(des);
   10994:	e51b000c 	ldr	r0, [fp, #-12]
   10998:	ebfffef7 	bl	1057c <add>

  head = new();
  if (head == NULL)
    exit(-1);

  for (i = 0; i < 10; i++) {
   1099c:	e51b3008 	ldr	r3, [fp, #-8]
   109a0:	e2833001 	add	r3, r3, #1
   109a4:	e50b3008 	str	r3, [fp, #-8]
   109a8:	e51b3008 	ldr	r3, [fp, #-8]
   109ac:	e3530009 	cmp	r3, #9
   109b0:	daffffee 	ble	10970 <main+0x40>
    des->value = i;
    des->index = i + 1;
    add(des);
  }
  
  display(0);
   109b4:	e3a00000 	mov	r0, #0
   109b8:	ebffff9a 	bl	10828 <display>
  del(2);
   109bc:	e3a00002 	mov	r0, #2
   109c0:	ebffff3f 	bl	106c4 <del>
  del(3);
   109c4:	e3a00003 	mov	r0, #3
   109c8:	ebffff3d 	bl	106c4 <del>
  del(6);
   109cc:	e3a00006 	mov	r0, #6
   109d0:	ebffff3b 	bl	106c4 <del>
  display(0);
   109d4:	e3a00000 	mov	r0, #0
   109d8:	ebffff92 	bl	10828 <display>

  des = new();
   109dc:	ebffff72 	bl	107ac <new>
   109e0:	e50b000c 	str	r0, [fp, #-12]
  des->value = 88;
   109e4:	e51b300c 	ldr	r3, [fp, #-12]
   109e8:	e3a02058 	mov	r2, #88	; 0x58
   109ec:	e5832008 	str	r2, [r3, #8]
  des->index = 88;
   109f0:	e51b300c 	ldr	r3, [fp, #-12]
   109f4:	e3a02058 	mov	r2, #88	; 0x58
   109f8:	e583200c 	str	r2, [r3, #12]
  add(des);
   109fc:	e51b000c 	ldr	r0, [fp, #-12]
   10a00:	ebfffedd 	bl	1057c <add>
  display(0);
   10a04:	e3a00000 	mov	r0, #0
   10a08:	ebffff86 	bl	10828 <display>

  des = new();
   10a0c:	ebffff66 	bl	107ac <new>
   10a10:	e50b000c 	str	r0, [fp, #-12]
  des->value = 77;
   10a14:	e51b300c 	ldr	r3, [fp, #-12]
   10a18:	e3a0204d 	mov	r2, #77	; 0x4d
   10a1c:	e5832008 	str	r2, [r3, #8]
  des->index = 77;
   10a20:	e51b300c 	ldr	r3, [fp, #-12]
   10a24:	e3a0204d 	mov	r2, #77	; 0x4d
   10a28:	e583200c 	str	r2, [r3, #12]
  add(des);
   10a2c:	e51b000c 	ldr	r0, [fp, #-12]
   10a30:	ebfffed1 	bl	1057c <add>
  display(0);
   10a34:	e3a00000 	mov	r0, #0
   10a38:	ebffff7a 	bl	10828 <display>
  
  des = new();
   10a3c:	ebffff5a 	bl	107ac <new>
   10a40:	e50b000c 	str	r0, [fp, #-12]
  des->value = 66;
   10a44:	e51b300c 	ldr	r3, [fp, #-12]
   10a48:	e3a02042 	mov	r2, #66	; 0x42
   10a4c:	e5832008 	str	r2, [r3, #8]
  des->index = 66;
   10a50:	e51b300c 	ldr	r3, [fp, #-12]
   10a54:	e3a02042 	mov	r2, #66	; 0x42
   10a58:	e583200c 	str	r2, [r3, #12]
  add(des);
   10a5c:	e51b000c 	ldr	r0, [fp, #-12]
   10a60:	ebfffec5 	bl	1057c <add>
  display(0);
   10a64:	e3a00000 	mov	r0, #0
   10a68:	ebffff6e 	bl	10828 <display>
}
   10a6c:	e1a00003 	mov	r0, r3
   10a70:	e24bd004 	sub	sp, fp, #4
   10a74:	e8bd8800 	pop	{fp, pc}
   10a78:	00020c0c 	.word	0x00020c0c

Disassembly of section .fini:

00010a7c <_fini>:
   10a7c:	e1a0c00d 	mov	ip, sp
   10a80:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   10a84:	e24cb004 	sub	fp, ip, #4
   10a88:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}
